/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org

Copyright (c) 2000-2009 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __CgFxScriptLoader_H__
#define __CgFxScriptLoader_H__

#include "OgrePrerequisites.h"
#include "OgreSingleton.h"
#include "OgreStringVector.h"
#include "OgreScriptLoader.h"
#include "OgreCgPrerequisites.h"
#include "OgreTexture.h"
#include "OgreTextureUnitState.h"
#include "OgreGpuProgram.h"

namespace Ogre {

    /** Manages Overlay objects, parsing them from .overlay files and
        storing a lookup library of them. Alo manages the creation of 
		OverlayContainers and OverlayElements, used for non-interactive 2D 
		elements such as HUDs.
    */
    class CgFxScriptLoader : public Singleton<CgFxScriptLoader>, public ScriptLoader, public ScriptCompilerAlloc
    {
    public:
    protected:
		/** we want to comply to FXCompositor - this list is the enum FXComposer.Core.FXSemanticID
			that existing in C:\Program Files\NVIDIA Corporation\FX Composer 2.5\FXComposer.Core.dll
			if you reference if from managed project you can see the list.
			description is from C:\Program Files\NVIDIA Corporation\FX Composer 2.5\Plugins\scene\render\Data\fxmapping.xml (open with a text editor and not with the browser)
			           and from C:\Program Files\NVIDIA Corporation\FX Composer 2.5\FXComposer.Core.xml
			*/
		enum FXSemanticID
		{
			FXS_NONE,
			FXS_UNKNOWN,
			FXS_POSITION, // desc="A position vector." datatypes="float3"
			FXS_DIRECTION, // desc="A direction vector." datatypes="float3"
			FXS_COLOR, 
			FXS_DIFFUSE, // desc="Color value to be used as the diffuse color.  The fourth channel represents diffuse alpha." datatypes="float4,float3,texture"
			FXS_SPECULAR, // desc="Color value to be used as the specular color.  The fourth channel represents specular alpha." datatypes="float4,float3,texture"
			FXS_AMBIENT, // desc="Color value to be used as the ambient color. The fourth channel represents ambient alpha." datatypes="float4,float3,texture"
			FXS_EMISSION,
			FXS_EMISSIVE, // desc="Color value to be used as the emissive color.  The fourth channel represents emissive alpha." datatypes="float4,float3,texture"
			FXS_SPECULARPOWER, // desc="Power to use for the specular exponent." datatypes="float,float3,float4"
			FXS_REFRACTION, // desc="A refraction map that give the coefficents to determine the norma for an environment map lookup" datatypes="texture"
			FXS_OPACITY, // desc="Opacity of the object." datatypes="texture"
			FXS_ENVIRONMENT, // desc="An environment map." datatypes="texture"
			FXS_ENVIRONMENTNORMAL, // name="environmentnormal" desc="An environment normal map." datatypes="texture"
			FXS_NORMAL, // desc="Normal for the element or texture" datatypes="texture"
			FXS_HEIGHT, // desc="Height for the element when using bump mapping." datatypes="texture"
			FXS_ATTENUATION, // desc="Light attenuation." datatypes="float3"
			FXS_RENDERCOLORTARGET, // desc="Defines the texture as the render target of a pass in the effect." datatypes="texture"
			FXS_RENDERDEPTHSTENCILTARGET, // desc="Defines the texture as the render target of a pass in the effect." datatypes="texture"
			FXS_VIEWPORTPIXELSIZE, // desc="Size of the viewport in pixels" datatypes="float2"
			FXS_CAMERAPOSITION, // desc="Viewer position in world space (replaced by position with space=view annotation)." datatypes="float3"
			FXS_TIME, // desc="The current time (see units annotation for scale)." datatypes="float"
			FXS_ELAPSEDTIME, // desc="The time between adjacent frames (see units annotation for scale)." datatypes="float"
			FXS_ANIMATIONTIME,
			FXS_ANIMATIONTICK,
			FXS_MOUSEPOSITION, // desc="The mouse position on screen (x,y,time)" datatypes="float3"
			FXS_LEFTMOUSEDOWN, // desc="The left mouse down state, and its position at that time ( x, y, isdown, timedown)" datatypes="float4"
			FXS_WORLD, // desc="world-inverse matrix." datatypes="matrix"
			FXS_VIEW, // desc="view matrix." datatypes="matrix"
			FXS_PROJECTION, // desc="projection matrix." datatypes="matrix"
			FXS_WORLDTRANSPOSE, // desc="world-transpose matrix." datatypes="matrix"
			FXS_VIEWTRANSPOSE, // name="worldviewtranspose" desc="world-view-transpose matrix." datatypes="matrix"
			FXS_PROJECTIONTRANSPOSE, // name="viewprojectiontranspose" desc="view-projection-transpose matrix." datatypes="matrix"
			FXS_WORLDVIEW, // desc="world-view matrix." datatypes="matrix"
			FXS_WORLDVIEWPROJECTION, // desc="world-view-projection matrix." datatypes="matrix"
			FXS_WORLDINVERSE, //desc="world-inverse matrix." datatypes="matrix"
			FXS_VIEWINVERSE, // desc="view-inverse matrix." datatypes="matrix"
			FXS_PROJECTIONINVERSE, // desc="projection-inverse matrix." datatypes="matrix"
			FXS_WORLDINVERSETRANSPOSE, // desc="world-inverse-transpose matrix." datatypes="matrix"
			FXS_VIEWINVERSETRANSPOSE, // desc="view-inverse-transpose matrix." datatypes="matrix"
			FXS_PROJECTIONINVERSETRANSPOSE, // desc="projection-inverse-transpose matrix." datatypes="matrix"
			FXS_WORLDVIEWINVERSE, // desc="world-view-inverse matrix." datatypes="matrix"
			FXS_WORLDVIEWTRANSPOSE, // desc="world-view-transpose matrix." datatypes="matrix"
			FXS_WORLDVIEWINVERSETRANSPOSE, // desc="world-view-inverse-transpose matrix." datatypes="matrix"
			FXS_WORLDVIEWPROJECTIONINVERSE, // desc="world-view-projection-inverse matrix." datatypes="matrix"
			FXS_WORLDVIEWPROJECTIONTRANSPOSE,
			FXS_WORLDVIEWPROJECTIONINVERSETRANSPOSE, // name="worldviewprojectioninversetranspose" desc="world-view-projection-inverse-transpose matrix." datatypes="matrix"
			FXS_VIEWPROJECTION, // desc="view-projection matrix." datatypes="matrix"
			FXS_VIEWPROJECTIONTRANSPOSE, // desc="view-projection-transpose matrix." datatypes="matrix"
			FXS_VIEWPROJECTIONINVERSE, // desc="world-view-projection-inverse matrix." datatypes="matrix"
			FXS_VIEWPROJECTIONINVERSETRANSPOSE, // desc="world-view-projection-inverse-transpose matrix." datatypes="matrix"
			FXS_FXCOMPOSER_RESETPULSE, // desc="A pulsed boolean, reset on window resize or from the FX Composer user interface." datatypes="bool"
			FXS_STANDARDSGLOBAL, // desc="Standards version and global annotations" datatypes="float"
			FXS_UNITSSCALE, // desc="Defines the modeling proportions to the current unit/space." datatypes="float"
			FXS_POWER, // Power factor
			FXS_DIFFUSEMAP, // A diffuse texture map
			FXS_SPECULARMAP, // A specular texture map
			FXS_ENVMAP, // An env map
			FXS_LIGHTPOSITION, // light position
			FXS_TRANSFORM, // A transform
			FXS_USER, // User Semantics - Semantics Remapper Special
			FXS_CONSTANTATTENUATION,
			FXS_LINEARATTENUATION,
			FXS_QUADRATICATTENUATION,
			FXS_FALLOFFANGLE,
			FXS_FALLOFFEXPONENT,
			FXS_BOUNDINGRADIUS
		};

		enum GlobalStateType
		{
			GST_UNKNOWN,
			GST_ALPHABLENDENABLE,  //AlphaBlendEnable
			GST_ALPHAFUNC,  //AlphaFunc
			GST_ALPHAREF,  //AlphaRef
			GST_BLENDOP,  //BlendOp
			GST_BLENDEQUATION,  //BlendEquation
			GST_BLENDFUNC,  //BlendFunc
			GST_BLENDFUNCSEPARATE,  //BlendFuncSeparate
			GST_BLENDEQUATIONSEPARATE,  //BlendEquationSeparate
			GST_BLENDCOLOR,  //BlendColor
			GST_CLEARCOLOR,  //ClearColor
			GST_CLEARSTENCIL,  //ClearStencil
			GST_CLEARDEPTH,  //ClearDepth
			GST_CLIPPLANE,  //ClipPlane
			GST_CLIPPLANEENABLE,  //ClipPlaneEnable
			GST_COLORWRITEENABLE,  //ColorWriteEnable
			GST_COLORMASK,  //ColorMask
			GST_COLORVERTEX,  //ColorVertex
			GST_COLORMATERIAL,  //ColorMaterial
			GST_COLORMATRIX,  //ColorMatrix
			GST_COLORTRANSFORM,  //ColorTransform
			GST_CULLFACE,  //CullFace
			GST_CULLMODE,  //CullMode
			GST_DEPTHBOUNDS,  //DepthBounds
			GST_DEPTHBIAS,  //DepthBias
			GST_DESTBLEND,  //DestBlend
			GST_DEPTHFUNC,  //DepthFunc
			GST_ZFUNC,  //ZFunc
			GST_DEPTHMASK,  //DepthMask
			GST_ZWRITEENABLE,  //ZWriteEnable
			GST_DEPTHRANGE,  //DepthRange
			GST_FOGDISTANCEMODE,  //FogDistanceMode
			GST_FOGMODE,  //FogMode
			GST_FOGTABLEMODE,  //FogTableMode
			GST_INDEXEDVERTEXBLENDENABLE,  //IndexedVertexBlendEnable
			GST_FOGDENSITY,  //FogDensity
			GST_FOGSTART,  //FogStart
			GST_FOGEND,  //FogEnd
			GST_FOGCOLOR,  //FogColor
			GST_FRAGMENTENVPARAMETER,  //FragmentEnvParameter
			GST_FRAGMENTLOCALPARAMETER,  //FragmentLocalParameter
			GST_FOGCOORDSRC,  //FogCoordSrc
			GST_FOGVERTEXMODE,  //FogVertexMode
			GST_FRONTFACE,  //FrontFace
			GST_LIGHTMODELAMBIENT,  //LightModelAmbient
			GST_AMBIENT,  //Ambient
			GST_LIGHTINGENABLE,  //LightingEnable
			GST_LIGHTENABLE,  //LightEnable
			GST_LIGHTAMBIENT,  //LightAmbient
			GST_LIGHTCONSTANTATTENUATION,  //LightConstantAttenuation
			GST_LIGHTATTENUATION0,  //LightAttenuation0
			GST_LIGHTDIFFUSE,  //LightDiffuse
			GST_LIGHTLINEARATTENUATION,  //LightLinearAttenuation
			GST_LIGHTATTENUATION1,  //LightAttenuation1
			GST_LIGHTPOSITION,  //LightPosition
			GST_LIGHTQUADRATICATTENUATION,  //LightQuadraticAttenuation
			GST_LIGHTATTENUATION2,  //LightAttenuation2
			GST_LIGHTSPECULAR,  //LightSpecular
			GST_LIGHTSPOTCUTOFF,  //LightSpotCutoff
			GST_LIGHTFALLOFF,  //LightFalloff
			GST_LIGHTSPOTDIRECTION,  //LightSpotDirection
			GST_LIGHTDIRECTION,  //LightDirection
			GST_LIGHTSPOTEXPONENT,  //LightSpotExponent
			GST_LIGHTPHI,  //LightPhi
			GST_LIGHTRANGE,  //LightRange
			GST_LIGHTTHETA,  //LightTheta
			GST_LIGHTTYPE,  //LightType
			GST_LOCALVIEWER,  //LocalViewer
			GST_MULTISAMPLEANTIALIAS,  //MultiSampleAntialias
			GST_MULTISAMPLEMASK,  //MultiSampleMask
			GST_PATCHSEGMENTS,  //PatchSegments
			GST_POINTSCALE_A,  //PointScale_A
			GST_POINTSCALE_B,  //PointScale_B
			GST_POINTSCALE_C,  //PointScale_C
			GST_POINTSCALEENABLE,  //PointScaleEnable
			GST_RANGEFOGENABLE,  //RangeFogEnable
			GST_SPECULARENABLE,  //SpecularEnable
			GST_TWEENFACTOR,  //TweenFactor
			GST_VERTEXBLEND,  //VertexBlend
			GST_AMBIENTMATERIALSOURCE,  //AmbientMaterialSource
			GST_DIFFUSEMATERIALSOURCE,  //DiffuseMaterialSource
			GST_EMISSIVEMATERIALSOURCE,  //EmissiveMaterialSource
			GST_SPECULARMATERIALSOURCE,  //SpecularMaterialSource
			GST_CLIPPING,  //Clipping
			GST_LIGHTMODELCOLORCONTROL,  //LightModelColorControl
			GST_LINESTIPPLE,  //LineStipple
			GST_LINEWIDTH,  //LineWidth
			GST_LOGICOP,  //LogicOp
			GST_MATERIALAMBIENT,  //MaterialAmbient
			GST_MATERIALDIFFUSE,  //MaterialDiffuse
			GST_MATERIALEMISSION,  //MaterialEmission
			GST_MATERIALEMISSIVE,  //MaterialEmissive
			GST_MATERIALSHININESS,  //MaterialShininess
			GST_MATERIALPOWER,  //MaterialPower
			GST_MATERIALSPECULAR,  //MaterialSpecular
			GST_MODELVIEWMATRIX,  //ModelViewMatrix
			GST_MODELVIEWTRANSFORM,  //ModelViewTransform
			GST_VIEWTRANSFORM,  //ViewTransform
			GST_WORLDTRANSFORM,  //WorldTransform
			GST_POINTDISTANCEATTENUATION,  //PointDistanceAttenuation
			GST_POINTFADETHRESHOLDSIZE,  //PointFadeThresholdSize
			GST_POINTSIZE,  //PointSize
			GST_POINTSIZEMIN,  //PointSizeMin
			GST_POINTSIZEMAX,  //PointSizeMax
			GST_POINTSPRITECOORDORIGIN,  //PointSpriteCoordOrigin
			GST_POINTSPRITECOORDREPLACE,  //PointSpriteCoordReplace
			GST_POINTSPRITERMODE,  //PointSpriteRMode
			GST_POLYGONMODE,  //PolygonMode
			GST_FILLMODE,  //FillMode
			GST_LASTPIXEL,  //LastPixel
			GST_POLYGONOFFSET,  //PolygonOffset
			GST_PROJECTIONMATRIX,  //ProjectionMatrix
			GST_PROJECTIONTRANSFORM,  //ProjectionTransform
			GST_SCISSOR,  //Scissor
			GST_SHADEMODEL,  //ShadeModel
			GST_SHADEMODE,  //ShadeMode
			GST_SLOPSCALEDEPTHBIAS,  //SlopScaleDepthBias
			GST_SRCBLEND,  //SrcBlend
			GST_STENCILFUNC,  //StencilFunc
			GST_STENCILMASK,  //StencilMask
			GST_STENCILPASS,  //StencilPass
			GST_STENCILREF,  //StencilRef
			GST_STENCILWRITEMASK,  //StencilWriteMask
			GST_STENCILZFAIL,  //StencilZFail
			GST_TEXTUREFACTOR,  //TextureFactor
			GST_STENCILOP,  //StencilOp
			GST_STENCILFUNCSEPARATE,  //StencilFuncSeparate
			GST_STENCILMASKSEPARATE,  //StencilMaskSeparate
			GST_STENCILOPSEPARATE,  //StencilOpSeparate
			GST_TEXGENSMODE,  //TexGenSMode
			GST_TEXGENSOBJECTPLANE,  //TexGenSObjectPlane
			GST_TEXGENSEYEPLANE,  //TexGenSEyePlane
			GST_TEXGENTMODE,  //TexGenTMode
			GST_TEXGENTOBJECTPLANE,  //TexGenTObjectPlane
			GST_TEXGENTEYEPLANE,  //TexGenTEyePlane
			GST_TEXGENRMODE,  //TexGenRMode
			GST_TEXGENROBJECTPLANE,  //TexGenRObjectPlane
			GST_TEXGENREYEPLANE,  //TexGenREyePlane
			GST_TEXGENQMODE,  //TexGenQMode
			GST_TEXGENQOBJECTPLANE,  //TexGenQObjectPlane
			GST_TEXGENQEYEPLANE,  //TexGenQEyePlane
			GST_TEXTUREENVCOLOR,  //TextureEnvColor
			GST_TEXTUREENVMODE,  //TextureEnvMode
			GST_TEXTURE1D,  //Texture1D
			GST_TEXTURE2D,  //Texture2D
			GST_TEXTURE3D,  //Texture3D
			GST_TEXTURERECTANGLE,  //TextureRectangle
			GST_TEXTURECUBEMAP,  //TextureCubeMap
			GST_TEXTURE1DENABLE,  //Texture1DEnable
			GST_TEXTURE2DENABLE,  //Texture2DEnable
			GST_TEXTURE3DENABLE,  //Texture3DEnable
			GST_TEXTURERECTANGLEENABLE,  //TextureRectangleEnable
			GST_TEXTURECUBEMAPENABLE,  //TextureCubeMapEnable
			GST_TEXTURETRANSFORM,  //TextureTransform
			GST_TEXTUREMATRIX,  //TextureMatrix
			GST_VERTEXENVPARAMETER,  //VertexEnvParameter
			GST_VERTEXLOCALPARAMETER,  //VertexLocalParameter
			GST_ALPHATESTENABLE,  //AlphaTestEnable
			GST_AUTONORMALENABLE,  //AutoNormalEnable
			GST_BLENDENABLE,  //BlendEnable
			GST_COLORLOGICOPENABLE,  //ColorLogicOpEnable
			GST_CULLFACEENABLE,  //CullFaceEnable
			GST_DEPTHBOUNDSENABLE,  //DepthBoundsEnable
			GST_DEPTHCLAMPENABLE,  //DepthClampEnable
			GST_DEPTHTESTENABLE,  //DepthTestEnable
			GST_ZENABLE,  //ZEnable
			GST_DITHERENABLE,  //DitherEnable
			GST_FOGENABLE,  //FogEnable
			GST_LIGHTMODELLOCALVIEWERENABLE,  //LightModelLocalViewerEnable
			GST_LIGHTMODELTWOSIDEENABLE,  //LightModelTwoSideEnable
			GST_LINESMOOTHENABLE,  //LineSmoothEnable
			GST_LINESTIPPLEENABLE,  //LineStippleEnable
			GST_LOGICOPENABLE,  //LogicOpEnable
			GST_MULTISAMPLEENABLE,  //MultisampleEnable
			GST_NORMALIZEENABLE,  //NormalizeEnable
			GST_POINTSMOOTHENABLE,  //PointSmoothEnable
			GST_POINTSPRITEENABLE,  //PointSpriteEnable
			GST_POLYGONOFFSETFILLENABLE,  //PolygonOffsetFillEnable
			GST_POLYGONOFFSETLINEENABLE,  //PolygonOffsetLineEnable
			GST_POLYGONOFFSETPOINTENABLE,  //PolygonOffsetPointEnable
			GST_POLYGONSMOOTHENABLE,  //PolygonSmoothEnable
			GST_POLYGONSTIPPLEENABLE,  //PolygonStippleEnable
			GST_RESCALENORMALENABLE,  //RescaleNormalEnable
			GST_SAMPLEALPHATOCOVERAGEENABLE,  //SampleAlphaToCoverageEnable
			GST_SAMPLEALPHATOONEENABLE,  //SampleAlphaToOneEnable
			GST_SAMPLECOVERAGEENABLE,  //SampleCoverageEnable
			GST_SCISSORTESTENABLE,  //ScissorTestEnable
			GST_STENCILTESTENABLE,  //StencilTestEnable
			GST_STENCILENABLE,  //StencilEnable
			GST_STENCILTESTTWOSIDEENABLE,  //StencilTestTwoSideEnable
			GST_STENCILFAIL,  //StencilFail
			GST_TEXGENSENABLE,  //TexGenSEnable
			GST_TEXGENTENABLE,  //TexGenTEnable
			GST_TEXGENRENABLE,  //TexGenREnable
			GST_TEXGENQENABLE,  //TexGenQEnable
			GST_WRAP0,  //Wrap0
			GST_WRAP1,  //Wrap1
			GST_WRAP2,  //Wrap2
			GST_WRAP3,  //Wrap3
			GST_WRAP4,  //Wrap4
			GST_WRAP5,  //Wrap5
			GST_WRAP6,  //Wrap6
			GST_WRAP7,  //Wrap7
			GST_WRAP8,  //Wrap8
			GST_WRAP9,  //Wrap9
			GST_WRAP10,  //Wrap10
			GST_WRAP11,  //Wrap11
			GST_WRAP12,  //Wrap12
			GST_WRAP13,  //Wrap13
			GST_WRAP14,  //Wrap14
			GST_WRAP15,  //Wrap15
			GST_VERTEXPROGRAMPOINTSIZEENABLE,  //VertexProgramPointSizeEnable
			GST_VERTEXPROGRAMTWOSIDEENABLE,  //VertexProgramTwoSideEnable
			GST_GEOMETRYPROGRAM,  //GeometryProgram
			GST_VERTEXPROGRAM,  //VertexProgram
			GST_FRAGMENTPROGRAM,  //FragmentProgram
			GST_VERTEXSHADER,  //VertexShader
			GST_PIXELSHADER,  //PixelShader
			GST_ALPHAOP,  //AlphaOp
			GST_ALPHAARG0,  //AlphaArg0
			GST_ALPHAARG1,  //AlphaArg1
			GST_ALPHAARG2,  //AlphaArg2
			GST_COLORARG0,  //ColorArg0
			GST_COLORARG1,  //ColorArg1
			GST_COLORARG2,  //ColorArg2
			GST_COLOROP,  //ColorOp
			GST_BUMPENVLSCALE,  //BumpEnvLScale
			GST_BUMPENVLOFFSET,  //BumpEnvLOffset
			GST_BUMPENVMAT00,  //BumpEnvMat00
			GST_BUMPENVMAT01,  //BumpEnvMat01
			GST_BUMPENVMAT10,  //BumpEnvMat10
			GST_BUMPENVMAT11,  //BumpEnvMat11
			GST_RESULTARG,  //ResultArg
			GST_TEXCOORDINDEX,  //TexCoordIndex
			GST_TEXTURETRANSFORMFLAGS,  //TextureTransformFlags
			GST_TWOSIDEDSTENCILMODE, // TwoSidedStencilMode
			GST_SEPARATEALPHABLENDENABLE, // SeparateAlphaBlendEnable
			GST_NORMALIZENORMALS, // NormalizeNormals
			GST_LIGHTING, // Lighting
			GST_PIXELSHADERCONSTANTB, // PixelShaderConstantB
			GST_VERTEXSHADERCONSTANTB, // VertexShaderConstantB
			GST_COLORWRITEENABLE1, // ColorWriteEnable1
			GST_COLORWRITEENABLE2, // ColorWriteEnable2
			GST_COLORWRITEENABLE3, // ColorWriteEnable3
			GST_PIXELSHADERCONSTANT1, // PixelShaderConstant1
			GST_VERTEXSHADERCONSTANT1, // VertexShaderConstant1
			GST_PIXELSHADERCONSTANTF, // PixelShaderConstantF
			GST_VERTEXSHADERCONSTANTF, // VertexShaderConstantF
			GST_PIXELSHADERCONSTANT2, // PixelShaderConstant2
			GST_VERTEXSHADERCONSTANT2, // VertexShaderConstant2
			GST_PIXELSHADERCONSTANT3, // PixelShaderConstant3
			GST_VERTEXSHADERCONSTANT3, // VertexShaderConstant3
			GST_PIXELSHADERCONSTANT, // PixelShaderConstant
			GST_VERTEXSHADERCONSTANT, // VertexShaderConstant
			GST_PIXELSHADERCONSTANT4, // PixelShaderConstant4
			GST_VERTEXSHADERCONSTANT4, // VertexShaderConstant4
			GST_PIXELSHADERCONSTANTI, // PixelShaderConstantI
			GST_VERTEXSHADERCONSTANTI, // VertexShaderConstantI
			GST_SAMPLER,  // Sampler
			GST_TEXTURE, // Texture

			GST_ADDRESSU, // AddressU
			GST_ADDRESSV, // AddressV
			GST_ADDRESSW, // AddressW
			GST_BORDERCOLOR, // BorderColor
			GST_MAXANISOTROPY, // MaxAnisotropy
			GST_MAXMIPLEVEL, // MaxMipLevel
			GST_MINFILTER, // MinFilter
			GST_MAGFILTER, // MagFilter
			GST_MIPFILTER, // MipFilter
			GST_MIPMAPLODBIAS, // MipMapLodBias
			GST_BLENDOPALPHA, // BlendOpAlpha
			GST_SRCBLENDALPHA, // SrcBlendAlpha
			GST_DESTBLENDALPHA, // DestBlendAlpha


			GST_COUNT
		};
#define GST_FIRST (GlobalStateType) (GST_UNKNOWN + (GlobalStateType)1)

		enum SamplerStateType
		{
			SST_UNKNOWN,
			SST_TEXTURE, // Texture
			SST_ADDRESSU, // AddressU
			SST_ADDRESSV, // AddressV
			SST_ADDRESSW, // AddressW
			SST_WRAPS, // WrapS
			SST_WRAPT, // WrapT
			SST_WRAPR, // WrapR
			SST_MIPFILTER, // MipFilter
			SST_MIPMAPLODBIAS, // MipMapLodBias
			SST_LODBIAS, // LODBias
			SST_SRGBTEXTURE, // SRGBTexture
			SST_MINFILTER, // MinFilter
			SST_MAGFILTER, // MagFilter
			SST_BORDERCOLOR, // BorderColor
			SST_MINMIPLEVEL, // MinMipLevel
			SST_MAXMIPLEVEL, // MaxMipLevel
			SST_MAXANISOTROPY, // MaxAnisotropy
			SST_DEPTHMODE, // DepthMode
			SST_COMPAREMODE, // CompareMode
			SST_COMPAREFUNC, // CompareFunc
			SST_GENERATEMIPMAP, // GenerateMipmap
			SST_COUNT,
		};

#define SST_FIRST (SamplerStateType) (SST_UNKNOWN + (SamplerStateType)1)

		// some simple types to make working with CGstateassignment easier

		struct Vector1b
		{
			bool x;
			Vector1b();
			Vector1b( bool iX );
			Vector1b( CGstateassignment cgStateAssignment );
			operator bool() const;
		};

		struct Vector2b
		{
			bool x, y;
			Vector2b();
			Vector2b( bool iX, bool iY , bool iZ, bool iW );
			Vector2b( CGstateassignment cgStateAssignment );
		};

		struct Vector3b
		{
			bool x, y, z;
			Vector3b();
			Vector3b( bool iX, bool iY , bool iZ, bool iW );
			Vector3b( CGstateassignment cgStateAssignment );
		};

		struct Vector4b
		{
			bool x, y, z, w;
			Vector4b();
			Vector4b( bool iX, bool iY , bool iZ, bool iW );
			Vector4b( CGstateassignment cgStateAssignment );
		};

		struct Vector1i
		{
			int x;
			Vector1i();
			Vector1i( int iX );
			Vector1i( CGstateassignment cgStateAssignment );
			operator int() const;

		};

		struct Vector2i
		{
			int x, y;
			Vector2i();
			Vector2i( int iX, int iY );
			Vector2i( CGstateassignment cgStateAssignment );
		};

		struct Vector3i
		{
			int x, y, z;
			Vector3i();
			Vector3i( int iX, int iY, int iZ );
			Vector3i( CGstateassignment cgStateAssignment );
		};


		struct Vector4i
		{
			int x, y, z, w;
			Vector4i();
			Vector4i( int iX, int iY, int iZ, int iW );
			Vector4i( CGstateassignment cgStateAssignment );
		};


		struct Vector1f
		{
			float x;
			Vector1f();
			Vector1f( float iX, float iY, float iZ );
			Vector1f( CGstateassignment cgStateAssignment );
			operator float() const;
		};


		struct Vector2f
		{
			float x, y;
			Vector2f();
			Vector2f( float iX, float iY, float iZ );
			Vector2f( CGstateassignment cgStateAssignment );
		};


		struct Vector3f
		{
			float x, y, z;
			Vector3f();
			Vector3f( float iX, float iY, float iZ );
			Vector3f( CGstateassignment cgStateAssignment );
		};

		struct Vector4f
		{
			float x, y, z, w;
			Vector4f();
			Vector4f( float iX, float iY, float iZ, float iW );
			Vector4f( CGstateassignment cgStateAssignment );
		};



		// simple types end


		class CgStateListener : public GeneralAllocatedObject
		{
		protected:
			CGstate mCgState;
			CGtype mCgType;
			CGcontext mCgContext;

			static CGbool cgCallBackSet( CGstateassignment cgStateAssignment );
			static CGbool cgCallBackReset( CGstateassignment cgStateAssignment );
			static CGbool cgCallBackValidate( CGstateassignment cgStateAssignment );

			virtual CGstatecallback getCgCallBackSet();
			virtual CGstatecallback getCgCallBackReset();
			virtual CGstatecallback getCgCallBackValidate();

			virtual void createState() = 0;
			void addStateEnumerant( int value, const char *name );

			CGparameter getCgParameter( CGstateassignment cgStateAssignment );


		public:
			CgStateListener( CGtype cgType );
			virtual ~CgStateListener();
			virtual void init();
			CGstate getCgState() const;
		};

		typedef vector<CgStateListener *>::type CgStateListenerVector;

		class CgGlobalStateListener : public CgStateListener
		{
		protected:
			const GlobalStateType mGlobalStateType;
			virtual void createState();
		public:
			CgGlobalStateListener( const GlobalStateType globalStateType, CGtype cgType );
			virtual ~CgGlobalStateListener();

			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Bool
		class CgBoolGlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector1b getValue( CGstateassignment cgStateAssignment );
		public:
			CgBoolGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Bool4
		class CgBool4GlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector4b getValue( CGstateassignment cgStateAssignment );
		public:
			CgBool4GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Float
		class CgFloatGlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector1f getValue( CGstateassignment cgStateAssignment );
		public:
			CgFloatGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Float2
		class CgFloat2GlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector2f getValue( CGstateassignment cgStateAssignment );
		public:
			CgFloat2GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Float3
		class CgFloat3GlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector3f getValue( CGstateassignment cgStateAssignment );
		public:
			CgFloat3GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Float4
		class CgFloat4GlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector4f getValue( CGstateassignment cgStateAssignment );
		public:
			CgFloat4GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Float4x2
		class CgFloat4x2GlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgFloat4x2GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Float4x3
		class CgFloat4x3GlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgFloat4x3GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Float4x4
		class CgFloat4x4GlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgFloat4x4GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Int
		class CgIntGlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector1i getValue( CGstateassignment cgStateAssignment );
		public:
			CgIntGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Int2
		class CgInt2GlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector2i getValue( CGstateassignment cgStateAssignment );
		public:
			CgInt2GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Int3
		class CgInt3GlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector3i getValue( CGstateassignment cgStateAssignment );
		public:
			CgInt3GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Int4
		class CgInt4GlobalStateListener : public CgGlobalStateListener
		{
		protected:
			const Vector4i getValue( CGstateassignment cgStateAssignment );
		public:
			CgInt4GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Sampler
		class CgSamplerGlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgSamplerGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Sampler2
		class CgSampler2GlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgSampler2GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Sampler3
		class CgSampler3GlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgSampler3GlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// SamplerCube
		class CgSamplerCubeGlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgSamplerCubeGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// SamplerRect
		class CgSamplerRectGlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgSamplerRectGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Texture
		class CgTextureGlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgTextureGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// Program
		class CgProgramGlobalStateListener : public CgGlobalStateListener
		{
		public:
			CgProgramGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};

		/// BlendEquation
		class CgBlendEquationGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum BlendEquationType
			{
				BET_FUNCADD, // FuncAdd
				BET_FUNCSUBTRACT,  // FuncSubtract
				BET_MIN, // Min
				BET_MAX,  // Max
				BET_LOGICOP, // LogicOp
			};
			virtual void createState();
		public:
			CgBlendEquationGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// DepthFunc
		class CgDepthFuncGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum DepthFuncType
			{
				DFT_NEVER,  // Never
				DFT_LESS, // Less
				DFT_LEQUAL,  // LEqual
				DFT_EQUAL, // Equal
				DFT_GREATER,  // Greater
				DFT_NOTEQUAL, // NotEqual
				DFT_GEQUAL,  // GEqual
				DFT_ALWAYS, // Always
			};
			virtual void createState();
		public:
			CgDepthFuncGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// FogDistanceMode
		class CgFogDistanceModeGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum FogDistanceModeType
			{
				FDMT_EYERADIAL, // EyeRadial
				FDMT_EYEPLANE, // EyePlane
				FDMT_EYEPLANEABSOLUTE, // EyePlaneAbsolute
			};
			virtual void createState();
		public:
			CgFogDistanceModeGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
		/// FogMode
		class CgFogModeGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum FogModeType
			{
				FMT_LINEAR, // Linear
				FMT_EXP,  // Exp
				FMT_EXP2, // Exp2
			};
			virtual void createState();
		public:
			CgFogModeGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};		
		
		/// LightModelColorControl
		class CgLightModelColorControlGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum LightModelColorControlType
			{
				LMCCT_SINGLECOLOR, // SingleColor
				LMCCT_SEPARATESPECULAR, // SeparateSpecular
			};
			virtual void createState();
		public:
			CgLightModelColorControlGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};		
		/// LogicOp
		class CgLogicOpGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum LogicOpType
			{
				LOT_CLEAR,  // Clear
				LOT_AND, // And
				LOT_ANDREVERSE,  // AndReverse
				LOT_COPY, // Copy
				LOT_ANDINVERTED,  // AndInverted
				LOT_NOOP, // Noop
				LOT_XOR,  // Xor
				LOT_OR,  // Or,
				LOT_NOR, // Nor
				LOT_EQUIV,  // Equiv
				LOT_INVERT, // Invert
				LOT_ORREVERSE, // OrReverse
				LOT_COPYINVERTED, // CopyInverted
				LOT_NAND,  // Nand
				LOT_SET, // Set
			};
			virtual void createState();
		public:
			CgLogicOpGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};		
		/// PointSpriteCoordOrigin
		class CgPointSpriteCoordOriginGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum PointSpriteCoordOriginType
			{
				PSCOT_LOWERLEFT, // LowerLeft
				PSCOT_UPPERLEFT, // UpperLeft
			};
			virtual void createState();
		public:
			CgPointSpriteCoordOriginGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};		
		/// PointSpriteRMode
		class CgPointSpriteRModeGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum PointSpriteRModeType
			{
				PSRMT_ZERO,  // Zero
				PSRMT_R,  // R
				PSRMT_S, // S
			};
			virtual void createState();
		public:
			CgPointSpriteRModeGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	
		/// ShadeModel
		class CgShadeModelGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum ShadeModelType
			{
				SMT_FLAT,  // Flat
				SMT_SMOOTH, // Smooth
			};
			virtual void createState();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		public:
			CgShadeModelGlobalStateListener();
		};	
		/// TexGenMode
		class CgTexGenModeGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum TexGenModeType
			{
				TGMT_OBJECTLINEAR, // ObjectLinear
				TGMT_EYELINEAR, // EyeLinear
				TGMT_SPHEREMAP, // SphereMap
				TGMT_REFLECTIONMAP, // ReflectionMap
				TGMT_NORMALMAP, // NormalMap
			};
			virtual void createState();
		public:
			CgTexGenModeGlobalStateListener( const GlobalStateType globalStateType );
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	
		/// TextureEnvMode
		class CgTextureEnvModeGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum TextureEnvModeType
			{
				BET_MODULATE,  // Modulate
				BET_DECAL, // Decal
				BET_BLEND,  // Blend
				BET_REPLACE, // Replace
				BET_ADD, // Add
			};
			virtual void createState();
		public:
			CgTextureEnvModeGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	
			/// MinFilter
			class CgMinFilterGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum MinFilterType
			{
				MFT_NEAREST,  // Nearest
				MFT_LINEAR, // Linear
				MFT_LINEARMIPMAPNEAREST, // LinearMipMapNearest
				MFT_NEARESTMIPMAPNEAREST, // NearestMipMapNearest
				MFT_NEARESTMIPMAPLINEAR, // NearestMipMapLinear
				MFT_LINEARMIPMAPLINEAR, // LinearMipMapLinear
			};
			virtual void createState();
		public:
			CgMinFilterGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	
		/// MagFilter
		class CgMagFilterGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum MagFilterType
			{
				MFT_NEAREST,  // Nearest
				MFT_LINEAR, // Linear
			};
			virtual void createState();
		public:
			CgMagFilterGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};		
			/// FrontFace
		class CgFrontFaceGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum FrontFaceType
			{
				FFT_CW, // CW
				FFT_CCW, // CCW
			};
			virtual void createState();
		public:
			CgFrontFaceGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	
		/// CullFaceGlobal - CullFace
		class CgCullFaceGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum CullFaceType
			{
				CFT_FRONT,  // Front
				CFT_BACK, // Back
				CFT_FRONTANDBACK, // FrontAndBack
			};
			virtual void createState();
		public:
			CgCullFaceGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	
		/// FogCoordSrcGlobal - FogCoordSrc
		class CgFogCoordSrcGlobalStateListener : public CgIntGlobalStateListener
		{
		protected:
			enum FogCoordSrcType
			{
				FCST_FRAGMENTDEPTH, // FragmentDepth
				FCST_FOGCOORD, // FogCoord
			};
			virtual void createState();
		public:
			CgFogCoordSrcGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	

		// AlphaFuncGlobal - float2 - reference then value
		class CgAlphaFuncGlobalStateListener : public CgFloat2GlobalStateListener
		{
		protected:
			enum AlphaFuncType
			{
				AFT_NEVER,  // Never
				AFT_LESS, // Less
				AFT_LEQUAL,  // LEqual
				AFT_EQUAL, // Equal
				AFT_GREATER,  // Greater
				AFT_NOTEQUAL, // NotEqual
				AFT_GEQUAL,  // GEqual
				AFT_ALWAYS, // Always
			};
			virtual void createState();
		public:
			CgAlphaFuncGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	
	
		// BlendFuncGlobal - Int2 - src_factor, dst_factor
		class CgBlendFuncGlobalStateListener : public CgInt2GlobalStateListener
		{
		protected:
			enum BlendFuncType
			{
				BF_ZERO,  // Zero
				BF_ONE, // One
				BF_DESTCOLOR, // DestColor
				BF_ONEMINUSDESTCOLOR, // OneMinusDestColor
				BF_SRCALPHA, // SrcAlpha
				BF_ONEMINUSSRCALPHA, // OneMinusSrcAlpha
				BF_DSTALPHA, // DstAlpha
				BF_ONEMINUSDSTALPHA, // OneMinusDstAlpha
				BF_SRCALPHASATURATE, // SrcAlphaSaturate
				BF_SRCCOLOR, // SrcColor
				BF_ONEMINUSSRCCOLOR, // OneMinusSrcColor
				BF_CONSTANTCOLOR, // ConstantColor
				BF_ONEMINUSCONSTANTCOLOR, // OneMinusConstantColor
				BF_CONSTANTALPHA, // ConstantAlpha
				BF_ONEMINUSCONSTANTALPHA, // OneMinusConstantAlpha
			};
			virtual void createState();
		public:
			CgBlendFuncGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};
	

		// BlendFuncSeparate - int4 (rgb_src, rgb_dst, a_src, a_dst)
		class CgBlendFuncSeparateGlobalStateListener : public CgInt4GlobalStateListener
		{
		protected:
			enum BlendFuncSeparateType
			{
				BFST_ZERO,  // Zero
				BFST_ONE, // One
				BFST_DESTCOLOR, // DestColor
				BFST_ONEMINUSDESTCOLOR, // OneMinusDestColor
				BFST_SRCALPHA, // SrcAlpha
				BFST_ONEMINUSSRCALPHA, // OneMinusSrcAlpha
				BFST_DSTALPHA, // DstAlpha
				BFST_ONEMINUSDSTALPHA, // OneMinusDstAlpha
				BFST_SRCALPHASATURATE, // SrcAlphaSaturate
				BFST_SRCCOLOR, // SrcColor
				BFST_ONEMINUSSRCCOLOR, // OneMinusSrcColor
				BFST_CONSTANTCOLOR, // ConstantColor
				BFST_ONEMINUSCONSTANTCOLOR, // OneMinusConstantColor
				BFST_CONSTANTALPHA, // ConstantAlpha
				BFST_ONEMINUSCONSTANTALPHA, // OneMinusConstantAlpha
			};
			virtual void createState();
		public:
			CgBlendFuncSeparateGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};

		// BlendEquationSeparate - int2 (rgb,alpha)
		class CgBlendEquationSeparateGlobalStateListener : public CgInt2GlobalStateListener
		{
		protected:
			enum BlendEquationSeparateType
			{
				BEST_FUNCADD, // FuncAdd
				BEST_FUNCSUBTRACT,  // FuncSubtract
				BEST_MIN, // Min
				BEST_MAX,  // Max
				BEST_LOGICOP, // LogicOp
			};
			virtual void createState();
		public:
			CgBlendEquationSeparateGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};


		// int2 
		class CgColorMaterialGlobalStateListener : public CgInt2GlobalStateListener
		{
		protected:
			enum ColorMaterialType
			{
				CMT_FRONT,  // Front
				CMT_BACK, // Back
				CMT_FRONTANDBACK, // FrontAndBack
				CMT_EMISSION,  // Emission
				CMT_AMBIENT, // Ambient
				CMT_DIFFUSE, // Diffuse
				CMT_SPECULAR, // Specular
				CMT_AMBIENTANDDIFFUSE, // AmbientAndDiffuse
			};
			virtual void createState();
		public:
			CgColorMaterialGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};				
	
		// int2 
		class CgPolygonModeGlobalStateListener : public CgInt2GlobalStateListener
		{
		protected:
			enum PolygonModeType
			{
				PMT_FRONT,  // Front
				PMT_BACK, // Back
				PMT_FRONTANDBACK, // FrontAndBack
				PMT_POINT,  // Point
				PMT_LINE,  // Line
				PMT_FILL, // Fill
			};
			virtual void createState();
		public:
			CgPolygonModeGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	

		// int3
		class CgStencilFuncGlobalStateListener : public CgInt3GlobalStateListener
		{
		protected:
			enum StencilFuncType
			{
				SFT_NEVER,  // Never
				SFT_LESS, // Less
				SFT_LEQUAL,  // LEqual
				SFT_EQUAL, // Equal
				SFT_GREATER, // Greater
				SFT_NOTEQUAL, // NotEqual
				SFT_GEQUAL,  // GEqual
				SFT_ALWAYS, // Always
			};
			virtual void createState();
		public:
			CgStencilFuncGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	

		// int3
		class CgStencilOpGlobalStateListener : public CgInt3GlobalStateListener
		{
		protected:
			enum StencilOpType
			{
				SOT_KEEP,  // Keep
				SOT_ZERO, // Zero
				SOT_REPLACE,  // Replace
				SOT_INCR, // Incr
				SOT_DECR,  // Decr
				SOT_INVERT, // Invert
				SOT_INCRWRAP,  // IncrWrap
				SOT_DECRWRAP, // DecrWrap
			};
			virtual void createState();
		public:
			CgStencilOpGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	

		// int4
		class CgStencilFuncSeparateGlobalStateListener : public CgInt4GlobalStateListener
		{
		protected:
			enum StencilFuncSeparateType
			{
				SFST_FRONT,  // Front
				SFST_BACK, // Back
				SFST_FRONTANDBACK, // FrontAndBack
				SFST_NEVER,  // Never
				SFST_LESS, // Less
				SFST_LEQUAL, // LEqual
				SFST_EQUAL, // Equal
				SFST_GREATER,  // Greater
				SFST_NOTEQUAL, // NotEqual
				SFST_GEQUAL,  // GEqual
				SFST_ALWAYS, // Always
			};
			virtual void createState();
		public:
			CgStencilFuncSeparateGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	

		// int2
		class CgStencilMaskSeparateGlobalStateListener : public CgInt2GlobalStateListener
		{
		protected:
			enum StencilMaskSeparateType
			{
				BET_FRONT,  // Front
				BET_BACK,  // Back
				BET_FRONTANDBACK, // FrontAndBack
			};
			virtual void createState();
		public:
			CgStencilMaskSeparateGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	

		// int4
		class CgStencilOpSeparateGlobalStateListener : public CgInt4GlobalStateListener
		{
		protected:
			enum StencilOpSeparateType
			{
				BET_KEEP, // Keep
				BET_ZERO, // Zero
				BET_REPLACE, // Replace
				BET_INCR, // Incr
				BET_DECR, // Decr
				BET_INVERT, // Invert
				BET_INCRWRAP,  // IncrWrap
				BET_DECRWRAP, // DecrWrap
			};
			virtual void createState();
		public:
			CgStencilOpSeparateGlobalStateListener();
			virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
		};	


		class CgSamplerStateListener : public CgStateListener
		{
		protected:
			SamplerStateType mSamplerStateType;
			virtual void createState();
		public:
			CgSamplerStateListener( const SamplerStateType samplerStateType, CGtype cgType );
			virtual ~CgSamplerStateListener();

			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// Int
		class CgIntSamplerStateListener : public CgSamplerStateListener
		{
		protected:
			const Vector1i getValue( CGstateassignment cgStateAssignment );
		public:
			CgIntSamplerStateListener( const SamplerStateType samplerStateType );
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// Bool
		class CgBoolSamplerStateListener : public CgSamplerStateListener
		{
		public:
			CgBoolSamplerStateListener( const SamplerStateType samplerStateType );
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// Float
		class CgFloatSamplerStateListener : public CgSamplerStateListener
		{
		public:
			CgFloatSamplerStateListener( const SamplerStateType samplerStateType );
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// Float4
		class CgFloat4SamplerStateListener : public CgSamplerStateListener
		{
		public:
			CgFloat4SamplerStateListener( const SamplerStateType samplerStateType );
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// Texture
		class CgTextureSamplerStateListener : public CgSamplerStateListener
		{
		protected:
			TextureType parseTextureType( CGparameter cgParameter, TextureUnitState * ogreTextureUnitState );
			void parseTextureName( CGparameter cgParameter, TextureUnitState * ogreTextureUnitState );
		public:
			CgTextureSamplerStateListener(const SamplerStateType samplerStateType);
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );

		};

		// Wrap	= TextureAddressingMode
		class CgWrapSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum WarpType
			{
				WT_REPEAT, // Repeat
				WT_CLAMP, // Clamp
				WT_CLAMPTOEDGE, // ClampToEdge
				WT_CLAMPTOBORDER, // ClampToBorder
				WT_MIRROREDREPEAT, // MirroredRepeat
				WT_MIRRORCLAMP, // MirrorClamp
				WT_MIRRORCLAMPTOEDGE, // MirrorClampToEdge
				WT_MIRRORCLAMPTOBORDER, // MirrorClampToBorder
			};
			virtual void createState();
			TextureUnitState::TextureAddressingMode getOgreTextureAddressingMode( CGstateassignment cgStateAssignment );
		public:
			CgWrapSamplerStateListener(const SamplerStateType samplerStateType);
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// CompareMode
		class CgCompareModeSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum CompareModeType
			{
				CMT_NONE, // None
				CMT_COMPARERTOTEXTURE, // CompareRToTexture
			};
			virtual void createState();
		public:
			CgCompareModeSamplerStateListener();
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// CompareFunc
		class CgCompareFuncSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum CompareFuncType
			{
				CFT_NEVER,  // Never
				CFT_LESS,  // Less
				CFT_LEQUAL, // LEqual
				CFT_EQUAL,  // Equal
				CFT_GREATER, // Greater
				CFT_NOTEQUAL, // NotEqual
			};
			virtual void createState();
		public:
			CgCompareFuncSamplerStateListener();
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// DepthMode
		class CgDepthModeSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum DepthModeType
			{
				DMT_ALPHA,   // Alpha
				DMT_INTENSITY,  // Intensity
				DMT_LUMINANCE,  // Luminance
			};
			virtual void createState();
		public:
			CgDepthModeSamplerStateListener();
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// MinFilter
		class CgMinFilterSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum MinFilterType
			{
				MINFT_NEAREST, // Nearest
				MINFT_LINEAR, // Linear
				MINFT_LINEARMIPMAPNEAREST, // LinearMipMapNearest
				MINFT_NEARESTMIPMAPNEAREST, // NearestMipMapNearest
				MINFT_NEARESTMIPMAPLINEAR, // NearestMipMapLinear
				MINFT_LINEARMIPMAPLINEAR, // LinearMipMapLinear
			};

			virtual void createState();
		public:
			CgMinFilterSamplerStateListener();
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// MagFilter
		class CgMagFilterSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum MagFilterType
			{
				MAGFT_NEAREST, // Nearest
				MAGFT_LINEAR, // Linear

			};

			virtual void createState();
		public:
			CgMagFilterSamplerStateListener();
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// MipFilter
		class CgMipFilterSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum MipFilterType
			{
				MIPFT_NONE            = 0,    // filtering disabled (valid for mip filter only)
				MIPFT_POINT           = 1,    // nearest
				MIPFT_LINEAR          = 2,    // linear interpolation
				MIPFT_ANISOTROPIC     = 3,    // anisotropic
				MIPFT_PYRAMIDALQUAD   = 6,    // 4-sample tent
				MIPFT_GAUSSIANQUAD    = 7,    // 4-sample gaussian

			};

			virtual void createState();
		public:
			CgMipFilterSamplerStateListener();
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};
		/// TextureAddress
		class CgTextureAddressSamplerStateListener : public CgIntSamplerStateListener
		{
		protected:
			enum TextureAddressType
			{
				TAT_WRAP = 1, // Wrap
				TAT_MIRROR, // Mirror
				TAT_CLAMP, // Clamp
				TAT_BORDER, // Border
				TAT_MIRRORONCE, // MirrorOnce
			};

			virtual void createState();
		public:
			CgTextureAddressSamplerStateListener( const SamplerStateType samplerStateType );
			virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
		};

		typedef map<CGstate, CgGlobalStateListener *>::type CgGlobalStateToListenerMap;
		typedef map<CGstate, CgSamplerStateListener *>::type CgSamplerStateToListenerMap;

		CgGlobalStateToListenerMap mCgGlobalStateToListenerMap;
		CgSamplerStateToListenerMap mCgSamplerStateToListenerMap;
		CgStateListenerVector mCgStateListenerVector;
		CgStateListenerVector mCgSamplerStateListenerVector;

		StringVector mScriptPatterns; // for getScriptPatterns(void)

		CGcontext mCgContext;
		CGcontext getCgContext() const;


		void parseCgEffect( CGeffect cgEffect, MaterialPtr ogreMaterial );
		void parseCgEffectTechniques( CGeffect cgEffect, MaterialPtr ogreMaterial );
		void parseCgTechnique( CGtechnique cgTechnique, Technique * ogreTechnique );
		void parseCgPass( CGpass cgPass, Pass * ogrePass );
		void parseSamplerParameters(CGpass cgPass, Pass * ogrePass);

		void parsePassStateAssignments( CGpass cgPass, Pass * ogrePass );
		void parseCgProgram( CGpass cgPass, Pass * ogrePass, const GpuProgramType ogreProgramType );
		void parseCgProgramParameters( CGpass cgPass, GpuProgramParametersSharedPtr ogreProgramParameters );
		void parseCgProgramParameter( CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
		void parseTextureUnitState( CGstateassignment cgStateAssignment, TextureUnitState * ogreTextureUnitState );

		void parseFloatCgProgramParameter( CGtype cgParamType, CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
		void parseIntCgProgramParameter( CGtype cgParamType, CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
		bool parseAutoConstantParam( CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
		const bool cgSemanticToOgreAutoConstantType( const char * cgParamSemantic, const char * uiNameValue, GpuProgramParameters::AutoConstantType & ogreAutoConstantType, size_t & extraInfo );
		const FXSemanticID cgSemanticStringToType( const char * cgParamSemantic );

		void buildStateNameStringToTypeMap();

		const char * getGlobalStateNameTypeToString( const GlobalStateType cgStateName );
		const char * getSamplerStateNameTypeToString( const SamplerStateType cgStateName );
		CgGlobalStateListener * createCgGlobalStateListener( const GlobalStateType type );
		CgSamplerStateListener * createCgSamplerStateListener( const SamplerStateType type );

	public:
        CgFxScriptLoader();
		virtual ~CgFxScriptLoader();

        /// @copydoc ScriptLoader::getScriptPatterns
        const StringVector& getScriptPatterns(void) const;
        /// @copydoc ScriptLoader::parseScript
        void parseScript( DataStreamPtr& stream, const String& groupName );

		/// @copydoc ScriptLoader::getLoadingOrder
        Real getLoadingOrder(void) const;

        /** Override standard Singleton retrieval.
        @remarks
        Why do we do this? Well, it's because the Singleton
        implementation is in a .h file, which means it gets compiled
        into anybody who includes it. This is needed for the
        Singleton template to work, but we actually only want it
        compiled into the implementation of the class based on the
        Singleton, not all of them. If we don't change this, we get
        link errors when trying to use the Singleton-based class from
        an outside dll.
        @par
        This method just delegates to the template version anyway,
        but the implementation stays in this single compilation unit,
        preventing link errors.
        */
        static CgFxScriptLoader& getSingleton(void);
        /** Override standard Singleton retrieval.
        @remarks
        Why do we do this? Well, it's because the Singleton
        implementation is in a .h file, which means it gets compiled
        into anybody who includes it. This is needed for the
        Singleton template to work, but we actually only want it
        compiled into the implementation of the class based on the
        Singleton, not all of them. If we don't change this, we get
        link errors when trying to use the Singleton-based class from
        an outside dll.
        @par
        This method just delegates to the template version anyway,
        but the implementation stays in this single compilation unit,
        preventing link errors.
        */
        static CgFxScriptLoader* getSingletonPtr(void);
	private:

		
	};



}


#endif 
